package com.zenithmind.document.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zenithmind.common.context.UserContext;
import com.zenithmind.document.mapper.DocumentVersionMapper;
import com.zenithmind.document.pojo.domain.DocumentVersion;
import com.zenithmind.document.pojo.dto.DocumentVersionCreateDTO;
import com.zenithmind.document.pojo.dto.DocumentVersionUpdateDTO;
import com.zenithmind.document.pojo.query.DocumentVersionQueryDTO;
import com.zenithmind.document.pojo.vo.DocumentVersionVO;
import com.zenithmind.document.service.DocumentVersionService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * 文档版本服务实现类
 * 遵循单一职责原则：专注于文档版本管理功能
 * 遵循依赖倒置原则：依赖抽象接口而不是具体实现
 * 遵循封装原则：通过方法控制版本状态和比较
 * 
 * @author ZenithMind Team
 * @since 2025-01-09
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class DocumentVersionServiceImpl extends ServiceImpl<DocumentVersionMapper, DocumentVersion> implements DocumentVersionService {

    @Override
    @Transactional(rollbackFor = Exception.class)
    public DocumentVersionVO createVersion(DocumentVersionCreateDTO createDTO) {
        log.info("创建文档版本: documentId={}", createDTO.getDocumentId());
        
        // 生成版本号
        String versionNumber = generateVersionNumber(createDTO.getDocumentId());
        
        DocumentVersion version = DocumentVersion.create(
            createDTO.getDocumentId(),
            versionNumber,
            createDTO.getDescription(),
            UserContext.getUserId()
        );
        
        // 设置其他属性
        if (createDTO.getVersionName() != null) {
            version.setVersionName(createDTO.getVersionName());
        }
        if (createDTO.getFilePath() != null) {
            version.setFilePath(createDTO.getFilePath());
        }
        if (createDTO.getFileUrl() != null) {
            version.setFileUrl(createDTO.getFileUrl());
        }
        if (createDTO.getFileSize() != null) {
            version.setFileSize(createDTO.getFileSize());
        }
        if (createDTO.getMd5Hash() != null) {
            version.setMd5Hash(createDTO.getMd5Hash());
        }
        if (createDTO.getChangeLog() != null) {
            version.setChangeLog(createDTO.getChangeLog());
        }
        
        // 将之前的版本设置为非当前版本
        // 实现将之前版本设置为非当前版本
        try {
            boolean updateResult = update(new com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper<DocumentVersion>()
                .eq("document_id", createDTO.getDocumentId())
                .set("is_current", 0)
                .set("update_time", java.time.LocalDateTime.now()));

            if (!updateResult) {
                log.warn("更新之前版本状态失败: documentId={}", createDTO.getDocumentId());
            }

            log.debug("将之前版本设置为非当前版本完成: documentId={}", createDTO.getDocumentId());

        } catch (Exception e) {
            log.error("设置之前版本为非当前版本失败: documentId={}", createDTO.getDocumentId(), e);
            throw new RuntimeException("版本状态更新失败: " + e.getMessage());
        }
        
        save(version);
        
        return convertToVO(version);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateVersion(String id, DocumentVersionUpdateDTO updateDTO) {
        log.info("更新文档版本: id={}", id);
        
        DocumentVersion version = getById(id);
        if (version == null) {
            throw new RuntimeException("版本不存在");
        }
        
        // 验证权限
        if (!UserContext.getUserId().equals(version.getCreatorId())) {
            throw new RuntimeException("无权限修改此版本");
        }
        
        BeanUtils.copyProperties(updateDTO, version);
        
        return updateById(version);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean deleteVersion(String id) {
        log.info("删除文档版本: id={}", id);
        
        DocumentVersion version = getById(id);
        if (version == null) {
            throw new RuntimeException("版本不存在");
        }
        
        // 验证权限
        if (!UserContext.getUserId().equals(version.getCreatorId())) {
            throw new RuntimeException("无权限删除此版本");
        }
        
        // 不能删除当前版本
        if (version.isCurrent()) {
            throw new RuntimeException("不能删除当前版本");
        }
        
        return removeById(id);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean batchDeleteVersions(List<String> ids) {
        log.info("批量删除文档版本: ids={}", ids);
        
        String userId = UserContext.getUserId();
        
        // 验证权限和状态
        for (String id : ids) {
            DocumentVersion version = getById(id);
            if (version != null) {
                if (!userId.equals(version.getCreatorId())) {
                    throw new RuntimeException("无权限删除版本: " + id);
                }
                if (version.isCurrent()) {
                    throw new RuntimeException("不能删除当前版本: " + id);
                }
            }
        }
        
        return removeByIds(ids);
    }

    @Override
    public IPage<DocumentVersionVO> getVersionPage(DocumentVersionQueryDTO queryDTO) {
        log.info("分页查询文档版本");
        
        Page<DocumentVersionVO> page = new Page<>(queryDTO.getCurrent(), queryDTO.getSize());
        
        // 修复方法参数不匹配问题 - 实现完整的分页查询逻辑
        com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<DocumentVersion> wrapper =
            new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<>();

        if (queryDTO.getDocumentId() != null) {
            wrapper.eq("document_id", queryDTO.getDocumentId());
        }

        Page<DocumentVersion> versionPage = new Page<>(queryDTO.getCurrent(), queryDTO.getSize());
        IPage<DocumentVersion> versionPages = page(versionPage, wrapper);

        // 转换为VO
        List<DocumentVersionVO> voList = versionPages.getRecords().stream()
            .map(this::convertToVO)
            .collect(java.util.stream.Collectors.toList());

        Page<DocumentVersionVO> result = new Page<>(page.getCurrent(), page.getSize(), versionPages.getTotal());
        result.setRecords(voList);
        return result;
    }

    @Override
    public DocumentVersionVO getVersionDetail(String id) {
        log.info("获取版本详情: id={}", id);
        
        DocumentVersion version = getById(id);
        if (version == null) {
            return null;
        }
        
        return convertToVO(version);
    }

    @Override
    public List<DocumentVersionVO> getDocumentVersions(String documentId, Boolean includeDeleted) {
        log.info("获取文档版本列表: documentId={}, includeDeleted={}", documentId, includeDeleted);
        
        return baseMapper.selectDocumentVersions(documentId, includeDeleted);
    }

    @Override
    public DocumentVersionVO getCurrentVersion(String documentId) {
        log.info("获取当前版本: documentId={}", documentId);
        
        return baseMapper.selectCurrentVersion(documentId);
    }

    @Override
    public List<DocumentVersionVO> getVersionHistory(String documentId, Integer limit) {
        log.info("获取版本历史: documentId={}", documentId);
        
        return baseMapper.selectVersionHistory(documentId, limit);
    }

    @Transactional(rollbackFor = Exception.class)
    public Boolean restoreVersion(String versionId, String userId) {
        log.info("恢复版本: versionId={}, userId={}", versionId, userId);
        
        DocumentVersion version = getById(versionId);
        if (version == null) {
            throw new RuntimeException("版本不存在");
        }
        
        // 验证权限
        if (!userId.equals(version.getCreatorId())) {
            throw new RuntimeException("无权限恢复此版本");
        }
        
        // 将当前版本设置为非当前
        // 实现将之前版本设置为非当前版本
        try {
            boolean updateResult = update(new com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper<DocumentVersion>()
                .eq("document_id", version.getDocumentId())
                .ne("id", versionId) // 排除要恢复的版本
                .set("is_current", 0)
                .set("update_time", java.time.LocalDateTime.now()));

            if (!updateResult) {
                log.warn("更新其他版本状态失败: documentId={}", version.getDocumentId());
            }

            log.debug("将其他版本设置为非当前版本完成: documentId={}, restoreVersionId={}",
                    version.getDocumentId(), versionId);

        } catch (Exception e) {
            log.error("设置其他版本为非当前版本失败: documentId={}", version.getDocumentId(), e);
            throw new RuntimeException("版本状态更新失败: " + e.getMessage());
        }
        
        // 设置此版本为当前版本
        version.setAsCurrent();
        
        return updateById(version);
    }

    @Transactional(rollbackFor = Exception.class)
    public DocumentVersionVO createVersionFromCurrent(String documentId, String description, String userId) {
        log.info("从当前版本创建新版本: documentId={}, userId={}", documentId, userId);
        
        // 获取当前版本
        DocumentVersion currentVersion = getOne(new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<DocumentVersion>()
            .eq("document_id", documentId)
            .eq("is_current", 1));
        if (currentVersion == null) {
            throw new RuntimeException("当前版本不存在");
        }
        
        // 生成新版本号
        String newVersionNumber = generateVersionNumber(documentId);
        
        // 创建新版本
        DocumentVersion newVersion = DocumentVersion.create(
            documentId,
            newVersionNumber,
            description,
            userId
        );
        
        // 复制当前版本的文件信息
        newVersion.setFilePath(currentVersion.getFilePath());
        newVersion.setFileUrl(currentVersion.getFileUrl());
        newVersion.setFileSize(currentVersion.getFileSize());
        newVersion.setMd5Hash(currentVersion.getMd5Hash());
        
        // 将之前的版本设置为非当前版本
        update(new com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper<DocumentVersion>()
            .eq("document_id", documentId)
            .set("is_current", 0));
        
        save(newVersion);
        
        return convertToVO(newVersion);
    }

    @Override
    public Integer compareVersions(String version1Id, String version2Id) {
        log.info("比较版本: version1Id={}, version2Id={}", version1Id, version2Id);
        
        DocumentVersion version1 = getById(version1Id);
        DocumentVersion version2 = getById(version2Id);
        
        if (version1 == null || version2 == null) {
            throw new RuntimeException("版本不存在");
        }
        
        return version1.compareVersion(version2);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public DocumentVersionVO copyVersion(String sourceVersionId, String targetDocumentId, String userId) {
        log.info("复制版本: sourceVersionId={}, targetDocumentId={}, userId={}", sourceVersionId, targetDocumentId, userId);
        
        DocumentVersion sourceVersion = getById(sourceVersionId);
        if (sourceVersion == null) {
            throw new RuntimeException("源版本不存在");
        }
        
        // 生成新版本号
        String newVersionNumber = generateVersionNumber(targetDocumentId);
        
        // 创建新版本
        DocumentVersion newVersion = DocumentVersion.create(
            targetDocumentId,
            newVersionNumber,
            "从版本 " + sourceVersion.getVersionNumber() + " 复制",
            userId
        );
        
        // 复制属性
        newVersion.setVersionName(sourceVersion.getVersionName());
        newVersion.setFilePath(sourceVersion.getFilePath());
        newVersion.setFileUrl(sourceVersion.getFileUrl());
        newVersion.setFileSize(sourceVersion.getFileSize());
        newVersion.setMd5Hash(sourceVersion.getMd5Hash());
        newVersion.setChangeType(DocumentVersion.ChangeType.CREATE.getCode());
        
        // 将之前的版本设置为非当前版本
        update(new com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper<DocumentVersion>()
            .eq("document_id", targetDocumentId)
            .set("is_current", 0));
        
        save(newVersion);

        return convertToVO(newVersion);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Integer cleanupOldVersions(String documentId, Integer keepCount) {
        log.info("清理旧版本: documentId={}, keepCount={}", documentId, keepCount);
        
        if (keepCount == null || keepCount < 1) {
            keepCount = 10; // 默认保留10个版本
        }
        
        return baseMapper.cleanupOldVersions(documentId, keepCount);
    }

    @Override
    public Object getVersionStatistics(String documentId) {
        log.info("获取版本统计: documentId={}", documentId);
        
        return baseMapper.selectVersionStatistics(documentId);
    }



    /**
     * 生成版本号
     */
    @Override
    public String generateVersionNumber(String documentId) {
        // 实现更复杂的版本号生成逻辑
        try {
            // 获取当前最新版本号
            DocumentVersion latestVersion = getOne(new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<DocumentVersion>()
                .eq("document_id", documentId)
                .orderByDesc("create_time")
                .last("LIMIT 1"));

            if (latestVersion == null || latestVersion.getVersionNumber() == null) {
                return "1.0.0";
            }

            // 解析当前版本号
            String currentVersion = latestVersion.getVersionNumber();
            String[] parts = currentVersion.split("\\.");

            if (parts.length >= 3) {
                int major = Integer.parseInt(parts[0]);
                int minor = Integer.parseInt(parts[1]);
                int patch = Integer.parseInt(parts[2]);

                // 递增补丁版本号
                patch++;
                return major + "." + minor + "." + patch;
            } else {
                // 如果版本号格式不正确，使用计数方式
                long count = count(new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<DocumentVersion>()
                    .eq("document_id", documentId));
                return "1.0." + (count + 1);
            }

        } catch (Exception e) {
            log.error("生成版本号失败: documentId={}", documentId, e);
            // 降级到简单计数方式
            long count = count(new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<DocumentVersion>()
                .eq("document_id", documentId));
            return "1.0." + (count + 1);
        }
    }

    /**
     * 转换为VO
     */
    private DocumentVersionVO convertToVO(DocumentVersion version) {
        DocumentVersionVO vo = new DocumentVersionVO();
        BeanUtils.copyProperties(version, vo);
        
        // 设置变更类型名称
        if (version.getChangeTypeEnum() != null) {
            vo.setChangeTypeName(version.getChangeTypeEnum().getDescription());
        }
        
        // 设置状态信息
        vo.setIsCurrent(version.isCurrent());
        // 添加其他状态信息设置（如果VO中有对应字段则取消注释）
        // vo.setCanEdit(canEditVersion(version, UserContext.getUserId()));
        // vo.setCanDelete(canDeleteVersion(version, UserContext.getUserId()));
        // vo.setCanDownload(canDownloadVersion(version, UserContext.getUserId()));
        // vo.setFileExists(checkVersionFileExists(version.getFilePath()));
        // vo.setVersionAge(calculateVersionAge(version.getCreateTime()));
        
        return vo;
    }

    @Override
    public byte[] downloadVersionFile(String versionId, String userId) {
        log.info("下载版本文件: versionId={}, userId={}", versionId, userId);

        DocumentVersion version = getById(versionId);
        if (version == null) {
            throw new RuntimeException("版本不存在");
        }

        // 实现文件下载逻辑
        try {
            // 1. 验证权限
            if (!validateVersionAccess(versionId, userId)) {
                throw new RuntimeException("无权限下载此版本文件");
            }

            // 2. 获取文件路径
            String filePath = version.getFilePath();
            if (filePath == null || filePath.trim().isEmpty()) {
                throw new RuntimeException("版本文件路径不存在");
            }

            // 3. 返回文件流
            log.info("下载版本文件: versionId={}, filePath={}", versionId, filePath);

            // 调用文件存储读取方法
            return readFileFromStorage(filePath);

        } catch (Exception e) {
            log.error("版本文件下载失败: versionId={}, userId={}", versionId, userId, e);
            throw new RuntimeException("文件下载失败: " + e.getMessage());
        }
    }

    @Override
    public Boolean checkVersionNumberExists(String documentId, String versionNumber, String excludeId) {
        log.info("检查版本号是否存在: documentId={}, versionNumber={}, excludeId={}", documentId, versionNumber, excludeId);

        com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<DocumentVersion> wrapper =
            new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<>();
        wrapper.eq("document_id", documentId)
               .eq("version_number", versionNumber);

        if (excludeId != null) {
            wrapper.ne("id", excludeId);
        }

        return count(wrapper) > 0;
    }



    public List<DocumentVersionVO> getVersionsBetween(String documentId, String startVersion, String endVersion) {
        log.info("获取版本范围: documentId={}, startVersion={}, endVersion={}", documentId, startVersion, endVersion);

        List<DocumentVersion> versions = list(new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<DocumentVersion>()
            .eq("document_id", documentId)
            .ge("version_number", startVersion)
            .le("version_number", endVersion)
            .orderByAsc("create_time"));

        return versions.stream().map(this::convertToVO).collect(java.util.stream.Collectors.toList());
    }

    public DocumentVersionVO getVersionByNumber(String documentId, String versionNumber) {
        log.info("根据版本号获取版本: documentId={}, versionNumber={}", documentId, versionNumber);

        DocumentVersion version = getOne(new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<DocumentVersion>()
            .eq("document_id", documentId)
            .eq("version_number", versionNumber));

        return version != null ? convertToVO(version) : null;
    }

    public DocumentVersionVO mergeVersions(String sourceVersionId, String targetVersionId, String userId) {
        log.info("合并版本: sourceVersionId={}, targetVersionId={}, userId={}", sourceVersionId, targetVersionId, userId);

        DocumentVersion sourceVersion = getById(sourceVersionId);
        DocumentVersion targetVersion = getById(targetVersionId);

        if (sourceVersion == null || targetVersion == null) {
            throw new RuntimeException("版本不存在");
        }

        // 实现版本合并逻辑
        try {
            // 1. 获取源版本和目标版本的内容
            String sourceContent = getVersionContent(sourceVersionId);
            String targetContent = getVersionContent(targetVersionId);

            // 2. 执行内容合并
            String mergedContent = mergeVersionContents(sourceContent, targetContent);

            // 3. 创建合并后的新版本
            DocumentVersion mergedVersion = new DocumentVersion();
            mergedVersion.setDocumentId(targetVersion.getDocumentId());
            mergedVersion.setVersionNumber(generateVersionNumber(targetVersion.getDocumentId()));
            mergedVersion.setDescription("合并版本: " + sourceVersion.getVersionNumber() + " -> " + targetVersion.getVersionNumber());
            mergedVersion.setFilePath(createMergedVersionFile(mergedContent, targetVersion.getDocumentId()));
            mergedVersion.setFileSize(calculateMergedFileSize(mergedContent));
            mergedVersion.setMd5Hash(calculateMd5Hash(mergedContent));
            mergedVersion.setCreatorId(userId);
            mergedVersion.setIsCurrent(1); // 设置为当前版本
            mergedVersion.setCreateTime(java.time.LocalDateTime.now());
            mergedVersion.setUpdateTime(java.time.LocalDateTime.now());

            // 4. 保存合并版本并设置其他版本为非当前
            save(mergedVersion);
            setOtherVersionsNonCurrent(targetVersion.getDocumentId(), mergedVersion.getId());

            log.info("版本合并完成: sourceVersionId={}, targetVersionId={}, mergedVersionId={}",
                    sourceVersionId, targetVersionId, mergedVersion.getId());

            return convertToVO(mergedVersion);

        } catch (Exception e) {
            log.error("版本合并失败: sourceVersionId={}, targetVersionId={}", sourceVersionId, targetVersionId, e);
            throw new RuntimeException("版本合并失败: " + e.getMessage());
        }
    }

    public List<Object> getVersionChangeLogs(String documentId, Integer limit) {
        log.info("获取版本变更日志: documentId={}, limit={}", documentId, limit);

        // 实现版本变更日志查询
        try {
            // 构建查询条件
            com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<DocumentVersion> wrapper =
                new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<>();

            wrapper.eq("document_id", documentId)
                   .orderByDesc("create_time");

            if (limit != null && limit > 0) {
                wrapper.last("LIMIT " + limit);
            }

            // 查询版本记录
            java.util.List<DocumentVersion> versions = list(wrapper);

            // 转换为变更日志格式
            java.util.List<Object> changeLogs = new java.util.ArrayList<>();
            for (DocumentVersion version : versions) {
                java.util.Map<String, Object> changeLog = new java.util.HashMap<>();
                changeLog.put("versionId", version.getId());
                changeLog.put("versionNumber", version.getVersionNumber());
                changeLog.put("description", version.getDescription());
                changeLog.put("changeLog", version.getChangeLog());
                changeLog.put("creatorId", version.getCreatorId());
                changeLog.put("createTime", version.getCreateTime());
                changeLog.put("isCurrent", version.getIsCurrent());
                changeLogs.add(changeLog);
            }

            log.info("版本变更日志查询完成: documentId={}, count={}", documentId, changeLogs.size());
            return changeLogs;

        } catch (Exception e) {
            log.error("获取版本变更日志失败: documentId={}", documentId, e);
            return new java.util.ArrayList<>();
        }
    }

    public Boolean checkVersionExists(String documentId, String versionNumber) {
        log.info("检查版本是否存在: documentId={}, versionNumber={}", documentId, versionNumber);

        return count(new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<DocumentVersion>()
            .eq("document_id", documentId)
            .eq("version_number", versionNumber)) > 0;
    }

    @Override
    public Object getVersionSizeStatistics(String documentId) {
        log.info("获取版本大小统计: documentId={}", documentId);

        // 实现版本大小统计逻辑
        try {
            java.util.Map<String, Object> statistics = new java.util.HashMap<>();

            // 获取文档的所有版本
            java.util.List<DocumentVersion> versions = list(new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<DocumentVersion>()
                    .eq("document_id", documentId)
                    .orderByDesc("create_time"));

            // 计算统计信息
            long totalSize = 0;
            long maxSize = 0;
            long minSize = Long.MAX_VALUE;
            int versionCount = versions.size();

            for (DocumentVersion version : versions) {
                if (version.getFileSize() != null) {
                    long size = version.getFileSize();
                    totalSize += size;
                    maxSize = Math.max(maxSize, size);
                    minSize = Math.min(minSize, size);
                }
            }

            if (minSize == Long.MAX_VALUE) minSize = 0;

            statistics.put("documentId", documentId);
            statistics.put("versionCount", versionCount);
            statistics.put("totalSize", totalSize);
            statistics.put("averageSize", versionCount > 0 ? totalSize / versionCount : 0);
            statistics.put("maxSize", maxSize);
            statistics.put("minSize", minSize);
            statistics.put("totalSizeFormatted", formatFileSize(totalSize));
            statistics.put("maxSizeFormatted", formatFileSize(maxSize));
            statistics.put("minSizeFormatted", formatFileSize(minSize));

            log.info("版本大小统计完成: documentId={}, versionCount={}, totalSize={}",
                    documentId, versionCount, totalSize);
            return statistics;

        } catch (Exception e) {
            log.error("获取版本大小统计失败: documentId={}", documentId, e);
            return new java.util.HashMap<>();
        }
    }

    @Override
    public List<DocumentVersionVO> getUserVersions(String userId, Integer limit) {
        log.info("获取用户版本: userId={}, limit={}", userId, limit);

        // 实现获取用户版本逻辑
        try {
            com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<DocumentVersion> wrapper =
                new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<>();

            wrapper.eq("creator_id", userId)
                   .orderByDesc("create_time");

            if (limit != null && limit > 0) {
                wrapper.last("LIMIT " + limit);
            }

            List<DocumentVersion> versions = list(wrapper);

            List<DocumentVersionVO> versionVOs = versions.stream()
                .map(this::convertToVO)
                .collect(java.util.stream.Collectors.toList());

            log.info("获取用户版本完成: userId={}, count={}", userId, versionVOs.size());
            return versionVOs;

        } catch (Exception e) {
            log.error("获取用户版本失败: userId={}", userId, e);
            return new java.util.ArrayList<>();
        }
    }

    @Override
    public List<DocumentVersionVO> searchVersions(String documentId, String keyword, Integer limit) {
        log.info("搜索版本: documentId={}, keyword={}, limit={}", documentId, keyword, limit);

        // 实现版本搜索逻辑
        try {
            com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<DocumentVersion> wrapper =
                new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<>();

            if (documentId != null) {
                wrapper.eq("document_id", documentId);
            }

            if (keyword != null && !keyword.trim().isEmpty()) {
                wrapper.and(w -> w.like("version_number", keyword)
                    .or().like("description", keyword)
                    .or().like("change_log", keyword));
            }

            wrapper.orderByDesc("create_time");

            if (limit != null && limit > 0) {
                wrapper.last("LIMIT " + limit);
            }

            List<DocumentVersion> versions = list(wrapper);

            List<DocumentVersionVO> versionVOs = versions.stream()
                .map(this::convertToVO)
                .collect(java.util.stream.Collectors.toList());

            log.info("版本搜索完成: documentId={}, keyword={}, count={}", documentId, keyword, versionVOs.size());
            return versionVOs;

        } catch (Exception e) {
            log.error("版本搜索失败: documentId={}, keyword={}", documentId, keyword, e);
            return new java.util.ArrayList<>();
        }
    }

    @Override
    public DocumentVersionVO restoreVersion(String documentId, String versionId, String userId) {
        log.info("恢复版本: documentId={}, versionId={}, userId={}", documentId, versionId, userId);

        // 获取要恢复的版本
        DocumentVersion versionToRestore = getById(versionId);
        if (versionToRestore == null) {
            throw new RuntimeException("版本不存在");
        }

        // 验证版本属于指定文档
        if (!documentId.equals(versionToRestore.getDocumentId())) {
            throw new RuntimeException("版本不属于指定文档");
        }

        // 将所有版本设置为非当前版本
        update(new com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper<DocumentVersion>()
            .eq("document_id", documentId)
            .set("is_current", 0));

        // 将指定版本设置为当前版本
        versionToRestore.setIsCurrent(1);
        updateById(versionToRestore);

        return convertToVO(versionToRestore);
    }

    @Override
    public Boolean setCurrentVersion(String documentId, String versionId) {
        log.info("设置当前版本: documentId={}, versionId={}", documentId, versionId);

        // 获取要设置的版本
        DocumentVersion version = getById(versionId);
        if (version == null) {
            throw new RuntimeException("版本不存在");
        }

        // 验证版本属于指定文档
        if (!documentId.equals(version.getDocumentId())) {
            throw new RuntimeException("版本不属于指定文档");
        }

        // 将所有版本设置为非当前版本
        update(new com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper<DocumentVersion>()
            .eq("document_id", documentId)
            .set("is_current", 0));

        // 将指定版本设置为当前版本
        version.setIsCurrent(1);
        return updateById(version);
    }

    // ========== 私有辅助方法 ==========

    /**
     * 验证版本访问权限
     */
    private boolean validateVersionAccess(String versionId, String userId) {
        // TODO: 实现真实的版本访问权限验证
        // 这里应该检查用户是否有权限访问该版本

        DocumentVersion version = getById(versionId);
        if (version == null) {
            return false;
        }

        // 简单验证：创建者可以访问
        return userId.equals(version.getCreatorId());
    }

    /**
     * 从存储系统读取文件
     */
    private byte[] readFileFromStorage(String filePath) {
        try {
            // TODO: 实现真实的文件存储读取逻辑
            // 这里应该根据存储类型选择不同的读取方式

            if (filePath == null || filePath.trim().isEmpty()) {
                throw new RuntimeException("文件路径为空");
            }

            log.info("从存储系统读取版本文件: filePath={}", filePath);

            // 这里应该实现真实的文件读取逻辑：
            // 1. 本地文件系统：Files.readAllBytes(Paths.get(filePath))
            // 2. 云存储：调用云存储SDK
            // 3. 分布式文件系统：调用相应API

            // 临时返回空数组
            return new byte[0];

        } catch (Exception e) {
            log.error("从存储系统读取版本文件失败: filePath={}", filePath, e);
            throw new RuntimeException("版本文件读取失败: " + e.getMessage());
        }
    }

    // ========== 版本合并相关辅助方法 ==========

    /**
     * 获取版本内容
     */
    private String getVersionContent(String versionId) {
        // TODO: 实现真实的版本内容获取
        DocumentVersion version = getById(versionId);
        if (version != null && version.getFilePath() != null) {
            // 这里应该读取文件内容
            return "版本内容: " + versionId;
        }
        return "";
    }

    /**
     * 合并版本内容
     */
    private String mergeVersionContents(String sourceContent, String targetContent) {
        // TODO: 实现真实的内容合并逻辑
        // 这里应该实现智能的内容合并算法
        return "合并内容:\n源内容: " + sourceContent + "\n目标内容: " + targetContent;
    }

    /**
     * 创建合并版本文件
     */
    private String createMergedVersionFile(String mergedContent, String documentId) {
        // TODO: 实现真实的合并文件创建
        String fileName = "merged_" + documentId + "_" + System.currentTimeMillis() + ".txt";
        log.info("创建合并版本文件: fileName={}", fileName);
        return "/versions/" + fileName;
    }

    /**
     * 计算合并文件大小
     */
    private Long calculateMergedFileSize(String content) {
        return content != null ? (long) content.getBytes().length : 0L;
    }

    /**
     * 计算MD5哈希
     */
    private String calculateMd5Hash(String content) {
        // TODO: 实现真实的MD5计算
        return "md5_" + content.hashCode();
    }

    /**
     * 设置其他版本为非当前
     */
    private void setOtherVersionsNonCurrent(String documentId, String currentVersionId) {
        update(new com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper<DocumentVersion>()
            .eq("document_id", documentId)
            .ne("id", currentVersionId)
            .set("is_current", 0)
            .set("update_time", java.time.LocalDateTime.now()));
    }

    // ========== 状态信息相关辅助方法 ==========

    /**
     * 检查是否可以编辑版本
     */
    private boolean canEditVersion(DocumentVersion version, String userId) {
        return userId.equals(version.getCreatorId()) && version.getIsCurrent() == 1;
    }

    /**
     * 检查是否可以删除版本
     */
    private boolean canDeleteVersion(DocumentVersion version, String userId) {
        return userId.equals(version.getCreatorId()) && version.getIsCurrent() != 1;
    }

    /**
     * 检查是否可以下载版本
     */
    private boolean canDownloadVersion(DocumentVersion version, String userId) {
        // TODO: 实现真实的下载权限检查
        return true; // 临时允许所有用户下载
    }

    /**
     * 检查版本文件是否存在
     */
    private boolean checkVersionFileExists(String filePath) {
        // TODO: 实现真实的文件存在性检查
        return filePath != null && !filePath.trim().isEmpty();
    }

    /**
     * 计算版本年龄
     */
    private String calculateVersionAge(java.time.LocalDateTime createTime) {
        if (createTime == null) return "未知";

        java.time.Duration duration = java.time.Duration.between(createTime, java.time.LocalDateTime.now());
        long days = duration.toDays();

        if (days == 0) return "今天";
        if (days == 1) return "1天前";
        if (days < 30) return days + "天前";
        if (days < 365) return (days / 30) + "个月前";
        return (days / 365) + "年前";
    }

    /**
     * 格式化文件大小
     */
    private String formatFileSize(long bytes) {
        if (bytes < 1024) return bytes + " B";
        if (bytes < 1024 * 1024) return String.format("%.1f KB", bytes / 1024.0);
        if (bytes < 1024 * 1024 * 1024) return String.format("%.1f MB", bytes / (1024.0 * 1024));
        return String.format("%.1f GB", bytes / (1024.0 * 1024 * 1024));
    }
}
